import db from '../database.js';

// 获取所有几何模型（可按章节筛选，用户端过滤隐藏的）
export const getAllModels = (req, res) => {
  try {
    const { chapter_id, admin } = req.query;
    let query = 'SELECT * FROM geometry_models';
    const conditions = [];
    const params = [];
    
    if (chapter_id) {
      conditions.push('chapter_id = ?');
      params.push(chapter_id);
    }
    
    // 用户端过滤隐藏的模型
    if (admin !== 'true') {
      conditions.push('is_hidden = 0');
    }
    
    if (conditions.length > 0) {
      query += ' WHERE ' + conditions.join(' AND ');
    }
    
    query += ' ORDER BY order_num ASC';
    
    const models = db.prepare(query).all(...params);
    res.json(models);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 获取单个几何模型
export const getModelById = (req, res) => {
  try {
    const model = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!model) {
      return res.status(404).json({ error: '模型不存在' });
    }
    res.json(model);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 创建几何模型（需要认证）
export const createModel = (req, res) => {
  try {
    const { chapter_id, title, canvas_data, order_num, is_special, template_path, is_hidden } = req.body;
    
    if (!chapter_id || !title || !canvas_data || order_num === undefined) {
      return res.status(400).json({ error: '缺少必要字段' });
    }
    
    // 验证特殊模型的template_path
    if (is_special && !template_path) {
      return res.status(400).json({ error: '特殊模型必须指定template_path' });
    }
    
    // 验证 canvas_data 是有效的 JSON
    let canvasDataStr;
    try {
      canvasDataStr = typeof canvas_data === 'string' ? canvas_data : JSON.stringify(canvas_data);
      JSON.parse(canvasDataStr);
    } catch (e) {
      return res.status(400).json({ error: 'canvas_data 必须是有效的 JSON' });
    }
    
    const result = db.prepare(`
      INSERT INTO geometry_models (chapter_id, title, canvas_data, order_num, is_special, template_path, is_hidden)
      VALUES (?, ?, ?, ?, ?, ?, ?)
    `).run(chapter_id, title, canvasDataStr, order_num, is_special ? 1 : 0, template_path || null, is_hidden ? 1 : 0);
    
    const newModel = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(result.lastInsertRowid);
    res.status(201).json(newModel);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 更新几何模型（需要认证）
export const updateModel = (req, res) => {
  try {
    const { chapter_id, title, canvas_data, order_num, is_special, template_path, is_hidden } = req.body;
    
    // 检查是否为特殊模型
    const existingModel = db.prepare('SELECT is_special FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!existingModel) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    // 特殊模型只允许修改标题、排序和隐藏状态，不允许修改其他字段
    if (existingModel.is_special === 1) {
      // 检查是否修改了不允许的字段
      const hasDisallowedChanges = canvas_data !== undefined ||
                                    is_special !== undefined ||
                                    template_path !== undefined;

      if (hasDisallowedChanges) {
        return res.status(403).json({ error: '特殊模型只允许修改标题、排序和隐藏状态' });
      }

      // 只允许修改标题、排序和隐藏状态
      if (title !== undefined || order_num !== undefined || is_hidden !== undefined) {
        const updates = [];
        const params = [];

        if (title !== undefined) {
          updates.push('title = ?');
          params.push(title);
        }
        if (order_num !== undefined) {
          updates.push('order_num = ?');
          params.push(order_num);
        }
        if (is_hidden !== undefined) {
          updates.push('is_hidden = ?');
          params.push(is_hidden ? 1 : 0);
        }

        updates.push('updated_at = CURRENT_TIMESTAMP');
        params.push(req.params.id);

        db.prepare(`UPDATE geometry_models SET ${updates.join(', ')} WHERE id = ?`).run(...params);
        const updatedModel = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(req.params.id);
        return res.json(updatedModel);
      }

      return res.status(400).json({ error: '没有要更新的字段' });
    }
    
    // 普通模型可以修改所有字段
    let canvasDataStr = canvas_data;
    if (canvas_data) {
      try {
        canvasDataStr = typeof canvas_data === 'string' ? canvas_data : JSON.stringify(canvas_data);
        JSON.parse(canvasDataStr);
      } catch (e) {
        return res.status(400).json({ error: 'canvas_data 必须是有效的 JSON' });
      }
    }
    
    const result = db.prepare(`
      UPDATE geometry_models 
      SET chapter_id = COALESCE(?, chapter_id),
          title = COALESCE(?, title),
          canvas_data = COALESCE(?, canvas_data),
          order_num = COALESCE(?, order_num),
          is_special = COALESCE(?, is_special),
          template_path = COALESCE(?, template_path),
          is_hidden = COALESCE(?, is_hidden),
          updated_at = CURRENT_TIMESTAMP
      WHERE id = ?
    `).run(
      chapter_id, 
      title, 
      canvasDataStr, 
      order_num, 
      is_special !== undefined ? (is_special ? 1 : 0) : null,
      template_path,
      is_hidden !== undefined ? (is_hidden ? 1 : 0) : null,
      req.params.id
    );
    
    if (result.changes === 0) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    const updatedModel = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(req.params.id);
    res.json(updatedModel);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 删除几何模型（需要认证）
export const deleteModel = (req, res) => {
  try {
    const existingModel = db.prepare('SELECT is_special FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!existingModel) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    if (existingModel.is_special === 1) {
      return res.status(403).json({ error: '特殊模型不允许删除，请使用专用接口' });
    }
    
    const result = db.prepare('DELETE FROM geometry_models WHERE id = ?').run(req.params.id);
    if (result.changes === 0) {
      return res.status(404).json({ error: '模型不存在' });
    }
    res.json({ message: '模型已删除' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 删除特殊模型（需要认证）
export const deleteSpecialModel = (req, res) => {
  try {
    const existingModel = db.prepare('SELECT is_special FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!existingModel) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    if (existingModel.is_special !== 1) {
      return res.status(400).json({ error: '该模型不是特殊模型' });
    }
    
    const result = db.prepare('DELETE FROM geometry_models WHERE id = ?').run(req.params.id);
    if (result.changes === 0) {
      return res.status(404).json({ error: '模型不存在' });
    }
    res.json({ message: '特殊模型已删除' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 更新特殊模型的模板路径（需要认证）
export const updateSpecialModelTemplate = (req, res) => {
  try {
    const { template_path } = req.body;
    
    if (!template_path) {
      return res.status(400).json({ error: 'template_path 是必需的' });
    }
    
    // 检查模型是否存在且为特殊模型
    const existingModel = db.prepare('SELECT is_special FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!existingModel) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    if (existingModel.is_special !== 1) {
      return res.status(400).json({ error: '该模型不是特殊模型' });
    }
    
    const result = db.prepare(`
      UPDATE geometry_models 
      SET template_path = ?,
          updated_at = CURRENT_TIMESTAMP
      WHERE id = ?
    `).run(template_path, req.params.id);
    
    if (result.changes === 0) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    const updatedModel = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(req.params.id);
    res.json(updatedModel);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// 更新特殊模型的隐藏状态（需要认证）
export const updateSpecialModelHidden = (req, res) => {
  try {
    const { is_hidden } = req.body;
    
    if (is_hidden === undefined) {
      return res.status(400).json({ error: 'is_hidden 是必需的' });
    }
    
    // 检查模型是否存在且为特殊模型
    const existingModel = db.prepare('SELECT is_special FROM geometry_models WHERE id = ?').get(req.params.id);
    if (!existingModel) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    if (existingModel.is_special !== 1) {
      return res.status(400).json({ error: '该模型不是特殊模型' });
    }
    
    const result = db.prepare(`
      UPDATE geometry_models 
      SET is_hidden = ?,
          updated_at = CURRENT_TIMESTAMP
      WHERE id = ?
    `).run(is_hidden ? 1 : 0, req.params.id);
    
    if (result.changes === 0) {
      return res.status(404).json({ error: '模型不存在' });
    }
    
    const updatedModel = db.prepare('SELECT * FROM geometry_models WHERE id = ?').get(req.params.id);
    res.json(updatedModel);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};
